package com.autumn.sms.service.services.impl;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.autumn.application.dto.PageQueryResult;
import com.autumn.application.dto.input.DefaultPrimaryKeyInput;
import com.autumn.application.dto.input.QueryCriteriaItemInput;
import com.autumn.mybatis.criterion.Criteria;
import com.autumn.mybatis.criterion.ISpecifyUpdateSection;
import com.autumn.mybatis.criterion.Query;
import com.autumn.sms.service.consts.ServiceConsts;
import com.autumn.sms.service.entities.PlatformTemplate;
import com.autumn.sms.service.entities.SmsAppInfo;
import com.autumn.sms.service.entities.SmsAppTemplate;
import com.autumn.sms.service.entities.SmsAppTemplatePlatform;
import com.autumn.sms.service.entities.StandardTemplate;
import com.autumn.sms.service.entities.views.AppPlatformTemplateParameterView;
import com.autumn.sms.service.entities.views.AppPlatformTemplateView;
import com.autumn.sms.service.entities.views.AppStandardTemplateParameterView;
import com.autumn.sms.service.entities.views.AppStandardTemplateView;
import com.autumn.sms.service.repositories.IPlatformTemplateRepository;
import com.autumn.sms.service.repositories.ISmsAppInfoRepository;
import com.autumn.sms.service.repositories.ISmsAppTemplatePlatformRepository;
import com.autumn.sms.service.repositories.ISmsAppTemplateRepository;
import com.autumn.sms.service.repositories.IStandardTemplateRepository;
import com.autumn.sms.service.repositories.views.IAppPlatformTemplateParameterViewRepository;
import com.autumn.sms.service.repositories.views.IAppPlatformTemplateViewPepository;
import com.autumn.sms.service.repositories.views.IAppStandardTemplateParameterViewRepository;
import com.autumn.sms.service.repositories.views.IAppStandardTemplateViewRepository;
import com.autumn.sms.service.services.ICacheService;
import com.autumn.sms.service.services.ISmsAppTemplateService;
import com.autumn.sms.service.services.dto.input.PageQueryByAppInput;
import com.autumn.sms.service.services.dto.input.SmsAppTemplateInput;
import com.autumn.sms.service.services.dto.input.SmsAppTemplatePlatformInput;
import com.autumn.sms.service.services.dto.input.SmsAppTemplateUpdateInput;
import com.autumn.sms.service.services.dto.output.SmsAppTemplateOutput;
import com.autumn.sms.service.services.dto.output.SmsAppTemplatePlatformOutput;
import com.autumn.sms.service.utils.AuditUtils;
import com.autumn.sms.service.vo.PlatformTemplateParameterValue;
import com.autumn.sms.service.vo.PlatformTemplateValue;
import com.autumn.sms.service.vo.SendTemplateValue;
import com.autumn.sms.service.vo.StandardTemplateParameterValue;
import com.autumn.sms.service.vo.StandardTemplateValue;
import com.autumn.util.AutoMapUtils;
import com.autumn.util.DataRollbackException;
import com.autumn.util.ExceptionUtils;
import com.autumn.util.StringUtils;
import com.autumn.util.json.JsonUtils;
import com.autumn.validation.ValidationException;

/**
 * 短信应用模板服务实现
 * 
 * @author 老码农
 *
 *         2018-01-12 13:36:30
 */
@Service
public class SmsAppTemplateServiceImpl extends AbstractBasicService<ISmsAppTemplateRepository, SmsAppTemplate>
		implements ISmsAppTemplateService {

	@Autowired
	private ISmsAppTemplateRepository appTemplateRepo;

	@Autowired
	private IPlatformTemplateRepository platformTemplateRepo;

	@Autowired
	private IStandardTemplateRepository standardTemplateRepo;

	@Autowired
	private ISmsAppTemplatePlatformRepository appTemplatePlatfromRepo;

	@Autowired
	private ICacheService cacheService;

	@Autowired
	private ISmsAppInfoRepository smsAppInfoRepository;
	@Autowired
	private IAppStandardTemplateViewRepository appStandardTemplateViewRepository;
	@Autowired
	private IAppStandardTemplateParameterViewRepository appStandardTemplateParameterViewRepository;
	@Autowired
	private IAppPlatformTemplateViewPepository appPlatformTemplateViewPepository;
	@Autowired
	private IAppPlatformTemplateParameterViewRepository appPlatformTemplateParameterViewRepository;

	@Override
	public SendTemplateValue getSendTemplate(String serviceId) {
		ExceptionUtils.checkNotNullOrBlank(serviceId, "serviceId");
		return cacheService.getSendTemplate(serviceId, (id) -> {
			return this.querySendTemplate(id);
		});
	}

	private SendTemplateValue querySendTemplate(String serviceId) {
		Query query = new Query(SmsAppInfo.class);
		query.eq("serviceId", serviceId).eq("status", ServiceConsts.Status.STATUS_RELEASE).eq("isDelete", false)
				.orderBy("id");
		// 查找应用
		SmsAppInfo appInfo = smsAppInfoRepository.selectFirst(query.builderSection());
		if (appInfo == null) {
			return null;
		}
		SendTemplateValue sendTemplate = new SendTemplateValue();
		sendTemplate.setServiceId(appInfo.getServiceId());
		sendTemplate.setServideName(appInfo.getServideName());
		sendTemplate.setServiceKey(appInfo.getServiceKey());

		// 查找应用对应的所有标准模板并装载
		query = new Query(AppStandardTemplateView.class);
		query.eq("appId", appInfo.getId()).eq("status", ServiceConsts.Status.STATUS_RELEASE).eq("isDelete", false)
				.eq("templateStatus", ServiceConsts.Status.STATUS_RELEASE).eq("templateIsDelete", false)
				.orderBy("sortId").orderBy("id");

		List<AppStandardTemplateView> smsTemplates = appStandardTemplateViewRepository
				.selectList(query.builderSection());
		for (AppStandardTemplateView smsTemplate : smsTemplates) {
			StandardTemplateValue stv = new StandardTemplateValue();
			stv.setTemplateId(smsTemplate.getTemplateId());
			stv.setTemplateCode(smsTemplate.getTemplateCode());
			stv.setTemplateName(smsTemplate.getTemplateName());
			stv.setIsRestrict(smsTemplate.getIsRestrict());
			stv.setRestrictSeconds(smsTemplate.getRestrictSeconds());
			stv.setIsVerificationCode(smsTemplate.getIsVerificationCode());
			stv.setVerificationCodeType(smsTemplate.getVerificationCodeType());

			sendTemplate.getTemplates().put(stv.getTemplateCode().toUpperCase(), stv);
		}
		if (sendTemplate.getTemplates().size() > 0) {
			// 查找标准模板对应的参数
			query = new Query(AppStandardTemplateParameterView.class);
			query.eq("appId", appInfo.getId()).eq("status", ServiceConsts.Status.STATUS_RELEASE)
					.eq("isDelete", false).eq("templateStatus", ServiceConsts.Status.STATUS_RELEASE)
					.eq("templateIsDelete", false).orderBy("templateParameterSortId").orderBy("id");

			List<AppStandardTemplateParameterView> templateParameters = appStandardTemplateParameterViewRepository
					.selectList(query.builderSection());

			// 模找模板对应的所有平台模板
			query = new Query(AppPlatformTemplateView.class);
			query.eq("appId", appInfo.getId()).eq("status", ServiceConsts.Status.STATUS_RELEASE)
					.eq("isDelete", false).eq("platformStatus", ServiceConsts.Status.STATUS_RELEASE)
					.eq("platformIsDelete", false)
					.eq("platformTemplateStatus", ServiceConsts.Status.STATUS_RELEASE)
					.eq("platformTemplateIsDelete", false).orderBy("autoSortId").orderBy("id");

			List<AppPlatformTemplateView> platformTemplates = appPlatformTemplateViewPepository
					.selectList(query.builderSection());

			// 模找模板对应的所有平台模板的参数
			query = new Query(AppPlatformTemplateParameterView.class);
			query.eq("appId", appInfo.getId()).eq("status", ServiceConsts.Status.STATUS_RELEASE)
					.eq("isDelete", false).eq("platformStatus", ServiceConsts.Status.STATUS_RELEASE)
					.eq("platformIsDelete", false)
					.eq("platformTemplateStatus", ServiceConsts.Status.STATUS_RELEASE)
					.eq("platformTemplateIsDelete", false).orderBy("autoSortId")
					.orderBy("platformTemplateParameterAutoSortId").orderBy("id");

			List<AppPlatformTemplateParameterView> platformTemplateParameters = appPlatformTemplateParameterViewRepository
					.selectList(query.builderSection());

			for (StandardTemplateValue stv : sendTemplate.getTemplates().values()) {
				// 装载标准参数
				for (AppStandardTemplateParameterView stpv : templateParameters) {
					if (stpv.getTemplateId().equals(stv.getTemplateId())) {
						StandardTemplateParameterValue stpValue = new StandardTemplateParameterValue();
						stpValue.setFriendlyName(stpv.getTemplateParameterFriendlyName());
						stpValue.setName(stpv.getTemplateParameterName());
						stpValue.setIsMust(stpv.getTemplateParameterIsMust());
						stv.getParameters().put(stpValue.getName().toUpperCase(), stpValue);
					}
				}
				// 装载平台模板
				for (AppPlatformTemplateView aptv : platformTemplates) {
					if (aptv.getTemplateId().equals(stv.getTemplateId())) {
						PlatformTemplateValue ptv = new PlatformTemplateValue();
						ptv.setTemplateCode(aptv.getPlatformTemplateCode());
						ptv.setTemplateName(aptv.getPlatformTemplateName());
						ptv.setSignName(aptv.getPlatformTemplateSignName());
						ptv.setPlatformCode(aptv.getPlatformCode());
						ptv.setPlatformName(aptv.getPlatformName());
						if (!StringUtils.isNullOrBlank(aptv.getPlatformConfigInfo())) {
							ptv.setConfigInfoMap(JsonUtils.parseMap(aptv.getPlatformConfigInfo().trim()));
						}
						// 装载平台模板参数
						for (AppPlatformTemplateParameterView aptpv : platformTemplateParameters) {
							if (aptpv.getPlatformTemplateId().equals(aptv.getPlatformTemplateId())) {
								PlatformTemplateParameterValue ptpv = new PlatformTemplateParameterValue();
								ptpv.setName(aptpv.getPlatformTemplateParameterName());
								ptpv.setFriendlyName(aptpv.getPlatformTemplateParameterFriendlyName());
								ptpv.setIsMust(aptpv.getPlatformTemplateParameterIsMust());
								ptpv.setStandardParameterName(
										aptpv.getPlatformTemplateParameterStandardName());
								ptv.getParameters().add(ptpv);
							}
						}
						stv.getPlatforms().add(ptv);
					}
				}
			}
		}
		return sendTemplate;
	}

	@Override
	@Transactional(rollbackFor = DataRollbackException.class)
	public SmsAppTemplateOutput add(SmsAppTemplateInput input) {
		// 检测应用是否存在
		checkIsExistAppInfoByPrimaryKey(input.getAppId());
		// 检测标准模板是否存在
		StandardTemplate standardTemplate = checkIsExistStandardTemplate(input.getTemplateId());
		SmsAppTemplate mapTo = AutoMapUtils.mapTo(SmsAppTemplate.class, input);
		mapTo.insertAuditingInitialize();
		// 新增应用模板设置为草稿状态
		mapTo.setStatus(ServiceConsts.Status.STATUS_DRAFT);
		appTemplateRepo.insert(mapTo);
		// 添加成功，添加应用模板下具有的应用-模板-平台 集合
		List<SmsAppTemplatePlatformInput> platformInputs = input.getAppTemplatePlatforms();
		List<SmsAppTemplatePlatformOutput> appTemplatePlatformOutputs = null;
		if (platformInputs != null && platformInputs.size() > 0) {
			List<SmsAppTemplatePlatform> platforms = AutoMapUtils.mapList(platformInputs,
					SmsAppTemplatePlatform.class);
			Map<Long, String> platTempName_map = new HashMap<>(8);
			for (int i = 0; i < platforms.size(); i++) {
				SmsAppTemplatePlatform item = platforms.get(i);
				item.setAutoSortId(i + 1);
				item.setAppTemplateId(mapTo.getId());
				// 检测平台-模板是否存在
				PlatformTemplate platformTemplate = checkIsExistPlatformTemplate(item.getPlatformTemplateId());
				// 若存在，检测平台模板对应的标准模板ID与应用模板中的标准模板是否一致
				Long standardTemplateId = platformTemplate.getStandardTemplateId();
				if (!standardTemplateId.equals(input.getTemplateId())) {
					throw new ValidationException(
							String.format("平台模板对应的标准模板ID[ %s ]与应用模板中的标准模板ID不一致", standardTemplateId));
				}
				//记录平台模板名称，随输出参数返回，用于前台展示
				platTempName_map.put(item.getPlatformTemplateId(), platformTemplate.getName());
			}
			appTemplatePlatfromRepo.batchInsert(platforms);
			appTemplatePlatformOutputs = AutoMapUtils.mapList(platforms, SmsAppTemplatePlatformOutput.class);
			//根据平台模板ID，取出平台模板名称，给输出参数赋值
			for (SmsAppTemplatePlatformOutput item : appTemplatePlatformOutputs) {
				item.setPlatformTemplateName(platTempName_map.get(item.getPlatformTemplateId()));
			}
		}
		SmsAppTemplateOutput smsAppTemplateOutput = AutoMapUtils.mapTo(SmsAppTemplateOutput.class, mapTo);
		smsAppTemplateOutput.setAppTemplatePlatforms(appTemplatePlatformOutputs);
		smsAppTemplateOutput.setTemplateName(standardTemplate.getName());
		return smsAppTemplateOutput;
	}

	/**
	 * 检测应用是否存在
	 * 
	 * @param appId
	 */
	private void checkIsExistAppInfoByPrimaryKey(Long appId) {
		Query query = AuditUtils.generateQueryById(SmsAppInfo.class, appId);
		AuditUtils.filterDelete(query);
		SmsAppInfo appInfo = smsAppInfoRepository.selectFirst(query.builderSection());
		if (appInfo == null) {
			throw new ValidationException(String.format("主键ID为[ %s ]的应用不存在", appId));
		}
	}

	/**
	 * 检测标准模板是否存在
	 * 
	 * @param standardTempalteId
	 * @return
	 */
	private StandardTemplate checkIsExistStandardTemplate(Long standardTempalteId) {
		Query query = AuditUtils.generateQueryById(StandardTemplate.class, standardTempalteId);
		AuditUtils.filterDelete(query);
		StandardTemplate standardTemplate = standardTemplateRepo.selectFirst(query.builderSection());
		if (standardTemplate == null) {
			throw new ValidationException(String.format("主键ID为[ %s ]的标准模板不存在", standardTempalteId));
		}
		return standardTemplate;
	}

	/**
	 * 检测平台-模板是否存在
	 * 
	 * @param platformTemplateId
	 * @return
	 */
	private PlatformTemplate checkIsExistPlatformTemplate(Long platformTemplateId) {
		Query query = AuditUtils.generateQueryById(PlatformTemplate.class, platformTemplateId);
		AuditUtils.filterDelete(query);
		PlatformTemplate platformTemplate = platformTemplateRepo.selectFirst(query.builderSection());
		if (platformTemplate == null) {
			throw new ValidationException(String.format("主键ID为[ %s ]的平台模板不存在", platformTemplateId));
		}
		return platformTemplate;
	}

	@Override
	@Transactional(rollbackFor = DataRollbackException.class)
	public SmsAppTemplateOutput modify(SmsAppTemplateInput input) {
		SmsAppTemplateUpdateInput updateInput = (SmsAppTemplateUpdateInput) input;
		// SmsAppTemplate appTemplate = checkIsExistEntityByPrimaryId(updateInput.getId());
		AppStandardTemplateView appTemplate = checkIsExistViewByPrimaryId(updateInput.getId());
		if (appTemplate.getStatus() == ServiceConsts.Status.STATUS_RELEASE) {
			throw new ValidationException("发布状态的应用模板不能修改");
		}
		if (!input.getAppId().equals(appTemplate.getAppId())) {
			checkIsExistAppInfoByPrimaryKey(input.getAppId());
		}
		Long templateId = input.getTemplateId();
		// 若更改了标准模板，检测新设置的标准模板是否存在，并检测该应用下同一标准模板的记录是否已存在
		if (!templateId.equals(appTemplate.getTemplateId())) {
			checkIsExistStandardTemplate(templateId);
			checkIsDuplicateRecordWithSameTemplateId(input.getAppId(), templateId);
		}
		// 删除该应用模板下的应用-模板-平台，
		Criteria criteria = new Criteria(SmsAppTemplatePlatform.class);
		criteria.eq("appTemplateId", updateInput.getId());
		appTemplatePlatfromRepo.deleteByWhere(criteria.builderSection());

		// 重新插入应用模板下具有的应用-模板-平台 集合
		List<SmsAppTemplatePlatformInput> platformInputs = input.getAppTemplatePlatforms();
		List<SmsAppTemplatePlatformOutput> appTemplatePlatformOutputs = null;
		if (platformInputs != null && platformInputs.size() > 0) {
			List<SmsAppTemplatePlatform> platforms = AutoMapUtils.mapList(platformInputs,
					SmsAppTemplatePlatform.class);
			Map<Long, String> platTempName_map = new HashMap<>(8);
			for (int i = 0; i < platforms.size(); i++) {
				SmsAppTemplatePlatform item = platforms.get(i);
				item.setAutoSortId(i + 1);
				item.setAppTemplateId(appTemplate.getId());
				// 检测平台-模板是否存在
				PlatformTemplate platformTemplate = checkIsExistPlatformTemplate(item.getPlatformTemplateId());
				// 若存在，检测平台模板对应的标准模板ID与应用模板中的标准模板是否一致
				Long standardTemplateId = platformTemplate.getStandardTemplateId();
				if (!standardTemplateId.equals(input.getTemplateId())) {
					throw new ValidationException(
							String.format("平台模板对应的标准模板ID[ %s ]与应用模板中的标准模板ID不一致", standardTemplateId));
				}
				//记录平台模板名称，随输出参数返回，用于前台展示
				platTempName_map.put(item.getPlatformTemplateId(), platformTemplate.getName());
			}
			appTemplatePlatfromRepo.batchInsert(platforms);
			appTemplatePlatformOutputs = AutoMapUtils.mapList(platforms, SmsAppTemplatePlatformOutput.class);
			//根据平台模板ID，取出平台模板名称，给输出参数赋值
			for (SmsAppTemplatePlatformOutput item : appTemplatePlatformOutputs) {
				item.setPlatformTemplateName(platTempName_map.get(item.getPlatformTemplateId()));
			}
		}
		SmsAppTemplateOutput smsAppTemplateOutput = AutoMapUtils.mapTo(SmsAppTemplateOutput.class, appTemplate);
		smsAppTemplateOutput.setAppTemplatePlatforms(appTemplatePlatformOutputs);
		return smsAppTemplateOutput;
	}

	/**
	 * 检测该应用下同一标准模板的记录是否已存在
	 * 
	 * @param appId
	 * @param templateId
	 */
	private void checkIsDuplicateRecordWithSameTemplateId(Long appId, Long templateId) {
		Query query = new Query(SmsAppTemplate.class);
		query.eq("appId", appId).eq("templateId", templateId);
		AuditUtils.filterDelete(query);
		SmsAppTemplate selectFirst = appTemplateRepo.selectFirst(query.builderSection());
		if (selectFirst != null) {
			throw new ValidationException(String.format("实体 [%s] 中应用ID为 [%s]，对应标准ID为 [%s] 的记录已存在",
					SmsAppTemplate.class.getSimpleName(), appId, templateId));
		}
	}

	@Override
	@Transactional(rollbackFor = DataRollbackException.class)
	public void delete(DefaultPrimaryKeyInput input) {
		SmsAppTemplate appTemplate = checkIsExistEntityByPrimaryId(input.getId());
		if (appTemplate.getStatus() == ServiceConsts.Status.STATUS_RELEASE) {
			throw new ValidationException("发布状态的应用模板不能删除");
		}
		ISpecifyUpdateSection section = AuditUtils.softDeleteById(SmsAppInfo.class, input.getId());
		appTemplateRepo.updateBySpecify(section);
		// 删除该应用模板下的应用-模板-平台
		Criteria criteria = new Criteria(SmsAppTemplatePlatform.class);
		criteria.eq("appTemplateId", input.getId());
		appTemplatePlatfromRepo.deleteByWhere(criteria.builderSection());
	}

	@Override
	public SmsAppTemplateOutput get(DefaultPrimaryKeyInput input) {
		AppStandardTemplateView smsAppTemplate = checkIsExistViewByPrimaryId(input.getId());
		// 获取该应用模板下的应用-模板-平台，
		Query query = new Query(AppPlatformTemplateView.class);
//		query.eq("appTemplateId", smsAppTemplate.getId());
		query.eq("appId", smsAppTemplate.getAppId()).eq("templateId", smsAppTemplate.getTemplateId());
		AuditUtils.filterDelete(query);
//		List<SmsAppTemplatePlatform> selectList = appTemplatePlatfromRepo.selectList(query.builderSection());
		List<AppPlatformTemplateView> selectList = appPlatformTemplateViewPepository.selectList(query.builderSection());
		List<SmsAppTemplatePlatformOutput> appTemplatePlatformOutputs = AutoMapUtils.mapList(selectList,
				SmsAppTemplatePlatformOutput.class);
		SmsAppTemplateOutput mapTo = AutoMapUtils.mapTo(SmsAppTemplateOutput.class, smsAppTemplate);
		mapTo.setAppTemplatePlatforms(appTemplatePlatformOutputs);
		return mapTo;
	}

	/**
	 * 根据视图主键ID检测该记录是否存在
	 * 
	 * @param id
	 * @return
	 */
	private AppStandardTemplateView checkIsExistViewByPrimaryId(Long id) {
		Query query = AuditUtils.generateQueryById(AppStandardTemplateView.class, id);
		AuditUtils.filterDelete(query);
		AppStandardTemplateView selectFirst = appStandardTemplateViewRepository.selectFirst(query.builderSection());
		if (selectFirst == null) {
			throw new ValidationException(String.format("视图 [%s] 中主键ID为 [%s] 的记录不存在",
					AppStandardTemplateView.class.getSimpleName(), id));
		}
		return selectFirst;
	}

	@Override
	protected ISmsAppTemplateRepository getRepository() {
		return appTemplateRepo;
	}

	@Override
	protected Class<SmsAppTemplate> getEntityClass() {
		return SmsAppTemplate.class;
	}

	@Override
	public void release(DefaultPrimaryKeyInput input) {
		SmsAppTemplate appTemplate = checkIsExistEntityByPrimaryId(input.getId());
		if (appTemplate.getStatus() == ServiceConsts.Status.STATUS_RELEASE) {
			throw new ValidationException(String.format("主键ID为 [%s] 的应用模板记录已发布", input.getId()));
		}
		// 检测该应用模板所属的应用是否已发布
		Long primaryId = appTemplate.getAppId();
		Query query = AuditUtils.generateQueryById(SmsAppInfo.class, primaryId);
		AuditUtils.filterDelete(query);
		SmsAppInfo appInfo = smsAppInfoRepository.selectFirst(query.builderSection());
		if (appInfo.getStatus() != ServiceConsts.Status.STATUS_RELEASE) {
			throw new ValidationException(String.format("主键ID为 [%s] 的应用记录未发布，请先发布该应用", primaryId));
		}
		// 检测应用模板对应的标准模板是否发布
		primaryId = appTemplate.getTemplateId();
		query = AuditUtils.generateQueryById(StandardTemplate.class, primaryId);
		AuditUtils.filterDelete(query);
		StandardTemplate standardTemplate = standardTemplateRepo.selectFirst(query.builderSection());
		if (standardTemplate.getStatus() != ServiceConsts.Status.STATUS_RELEASE) {
			throw new ValidationException(String.format("主键ID为 [%s] 的标准模板记录未发布，请先发布该标准模板", primaryId));
		}
		appTemplate.updateAuditing();
		appTemplate.setStatus(ServiceConsts.Status.STATUS_RELEASE);
		appTemplateRepo.update(appTemplate);
		// 通过应用的serivceId，刷新具体应用发送模板的redis缓存
		cacheService.removeSendTemplate(appInfo.getServiceId());
	}

	@Override
	public void disable(DefaultPrimaryKeyInput input) {
		SmsAppTemplate appTemplate = checkIsExistEntityByPrimaryId(input.getId());
		if (appTemplate.getStatus() == ServiceConsts.Status.STATUS_DISABLE) {
			throw new ValidationException(String.format("主键ID为 [%s] 的应用模板记录已停用", input.getId()));
		}
		appTemplate.updateAuditing();
		appTemplate.setStatus(ServiceConsts.Status.STATUS_DISABLE);
		appTemplateRepo.update(appTemplate);

		// 刷新redis缓存
		cacheService.removeAllSendTemplate();
	}

	@Override
	public PageQueryResult<SmsAppTemplateOutput> pageQueryByAppId(PageQueryByAppInput input) {
		Query query = new Query(AppStandardTemplateView.class);
		List<QueryCriteriaItemInput> criterias = input.getCriterias();
		if (criterias != null && criterias.size() > 0) {
			query.criteria(criterias);
		}
		query.eq("isDelete", false).eq("appId", input.getAppId());
		int count = appStandardTemplateViewRepository.countByWhere(query.builderSection());
		int maxValue = getPageMaxValue();
		if (input.getPageSize() > maxValue) {
			input.setPageSize(maxValue);
		}
		PageQueryResult<SmsAppTemplateOutput> result = new PageQueryResult<>(input.getCurrentPage(),
				input.getPageSize(), count);
		if (count > 0) {
			query.page(result.getCurrentPage(), result.getPageSize());
			List<AppStandardTemplateView> selectList = appStandardTemplateViewRepository.selectList(query.builderSection());
			result.setItems(AutoMapUtils.mapList(selectList, SmsAppTemplateOutput.class));
		}
		return result;
	}

}
